home *** CD-ROM | disk | FTP | other *** search
/ Chip 2007 January, February, March & April / Chip-Cover-CD-2007-02.iso / Pakiet bezpieczenstwa / mini Pentoo LiveCD 2006.1 / mpentoo-2006.1.iso / livecd.squashfs / usr / include / X11 / extensions / XKBstr.h < prev    next >
C/C++ Source or Header  |  2006-04-12  |  18KB  |  615 lines
  1. /* $Xorg: XKBstr.h,v 1.3 2000/08/18 04:05:45 coskrey Exp $ */
  2. /************************************************************
  3. Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
  4.  
  5. Permission to use, copy, modify, and distribute this
  6. software and its documentation for any purpose and without
  7. fee is hereby granted, provided that the above copyright
  8. notice appear in all copies and that both that copyright
  9. notice and this permission notice appear in supporting
  10. documentation, and that the name of Silicon Graphics not be 
  11. used in advertising or publicity pertaining to distribution 
  12. of the software without specific prior written permission.
  13. Silicon Graphics makes no representation about the suitability 
  14. of this software for any purpose. It is provided "as is"
  15. without any express or implied warranty.
  16.  
  17. SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
  18. SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
  19. AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  20. GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
  21. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
  22. DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
  23. OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  24. THE USE OR PERFORMANCE OF THIS SOFTWARE.
  25.  
  26. ********************************************************/
  27.  
  28. #ifndef _XKBSTR_H_
  29. #define    _XKBSTR_H_
  30.  
  31. #include <X11/extensions/XKB.h>
  32.  
  33. #define    XkbCharToInt(v)        ((v)&0x80?(int)((v)|(~0xff)):(int)((v)&0x7f))
  34. #define    XkbIntTo2Chars(i,h,l)    (((h)=((i>>8)&0xff)),((l)=((i)&0xff)))
  35.  
  36. #if defined(WORD64) && defined(UNSIGNEDBITFIELDS)
  37. #define    Xkb2CharsToInt(h,l)    ((h)&0x80?(int)(((h)<<8)|(l)|(~0xffff)):\
  38.                       (int)(((h)<<8)|(l)&0x7fff))
  39. #else
  40. #define    Xkb2CharsToInt(h,l)    ((short)(((h)<<8)|(l)))
  41. #endif
  42.  
  43.     /*
  44.      * Common data structures and access macros
  45.      */
  46.  
  47. typedef struct _XkbStateRec {
  48.     unsigned char    group;
  49.     unsigned char   locked_group;
  50.     unsigned short    base_group;
  51.     unsigned short    latched_group;
  52.     unsigned char    mods;
  53.     unsigned char    base_mods;
  54.     unsigned char    latched_mods;
  55.     unsigned char    locked_mods;
  56.     unsigned char    compat_state;
  57.     unsigned char    grab_mods;
  58.     unsigned char    compat_grab_mods;
  59.     unsigned char    lookup_mods;
  60.     unsigned char    compat_lookup_mods;
  61.     unsigned short    ptr_buttons;
  62. } XkbStateRec,*XkbStatePtr;
  63. #define    XkbModLocks(s)     ((s)->locked_mods)
  64. #define    XkbStateMods(s)     ((s)->base_mods|(s)->latched_mods|XkbModLocks(s))
  65. #define    XkbGroupLock(s)     ((s)->locked_group)
  66. #define    XkbStateGroup(s) ((s)->base_group+(s)->latched_group+XkbGroupLock(s))
  67. #define    XkbStateFieldFromRec(s)    XkbBuildCoreState((s)->lookup_mods,(s)->group)
  68. #define    XkbGrabStateFromRec(s)    XkbBuildCoreState((s)->grab_mods,(s)->group)
  69.  
  70. typedef struct _XkbMods {
  71.     unsigned char    mask;    /* effective mods */
  72.     unsigned char    real_mods;
  73.     unsigned short    vmods;
  74. } XkbModsRec,*XkbModsPtr;
  75.  
  76. typedef struct _XkbKTMapEntry {
  77.     Bool        active;
  78.     unsigned char    level;
  79.     XkbModsRec    mods;
  80. } XkbKTMapEntryRec,*XkbKTMapEntryPtr;
  81.  
  82. typedef struct _XkbKeyType {
  83.     XkbModsRec        mods;
  84.     unsigned char          num_levels;
  85.     unsigned char          map_count;
  86.     XkbKTMapEntryPtr      map;
  87.     XkbModsPtr          preserve;
  88.     Atom              name;
  89.     Atom *            level_names;
  90. } XkbKeyTypeRec, *XkbKeyTypePtr;
  91.  
  92. #define    XkbNumGroups(g)            ((g)&0x0f)
  93. #define    XkbOutOfRangeGroupInfo(g)    ((g)&0xf0)
  94. #define    XkbOutOfRangeGroupAction(g)    ((g)&0xc0)
  95. #define    XkbOutOfRangeGroupNumber(g)    (((g)&0x30)>>4)
  96. #define    XkbSetGroupInfo(g,w,n)    (((w)&0xc0)|(((n)&3)<<4)|((g)&0x0f))
  97. #define    XkbSetNumGroups(g,n)    (((g)&0xf0)|((n)&0x0f))
  98.  
  99.     /*
  100.      * Structures and access macros used primarily by the server
  101.      */
  102.  
  103. typedef struct _XkbBehavior {
  104.     unsigned char    type;
  105.     unsigned char    data;
  106. } XkbBehavior;
  107.  
  108. #define    XkbAnyActionDataSize 7
  109. typedef    struct _XkbAnyAction {
  110.     unsigned char    type;
  111.     unsigned char    data[XkbAnyActionDataSize];
  112. } XkbAnyAction;
  113.  
  114. typedef struct _XkbModAction {
  115.     unsigned char    type;
  116.     unsigned char    flags;
  117.     unsigned char    mask;
  118.     unsigned char    real_mods;
  119.     unsigned char    vmods1;
  120.     unsigned char    vmods2;
  121. } XkbModAction;
  122. #define    XkbModActionVMods(a)      \
  123.     ((short)(((a)->vmods1<<8)|((a)->vmods2)))
  124. #define    XkbSetModActionVMods(a,v) \
  125.     (((a)->vmods1=(((v)>>8)&0xff)),(a)->vmods2=((v)&0xff))
  126.  
  127. typedef struct _XkbGroupAction {
  128.     unsigned char    type;
  129.     unsigned char    flags;
  130.     char        group_XXX;
  131. } XkbGroupAction;
  132. #define    XkbSAGroup(a)        (XkbCharToInt((a)->group_XXX))
  133. #define    XkbSASetGroup(a,g)    ((a)->group_XXX=(g))
  134.  
  135. typedef struct _XkbISOAction {
  136.     unsigned char    type;
  137.     unsigned char    flags;
  138.     unsigned char    mask;
  139.     unsigned char    real_mods;
  140.     char        group_XXX;
  141.     unsigned char    affect;
  142.     unsigned char    vmods1;
  143.     unsigned char    vmods2;
  144. } XkbISOAction;
  145.  
  146. typedef struct _XkbPtrAction {
  147.     unsigned char    type;
  148.     unsigned char    flags;
  149.     unsigned char    high_XXX;
  150.     unsigned char    low_XXX;
  151.     unsigned char    high_YYY;
  152.     unsigned char    low_YYY;
  153. } XkbPtrAction;
  154. #define    XkbPtrActionX(a)      (Xkb2CharsToInt((a)->high_XXX,(a)->low_XXX))
  155. #define    XkbPtrActionY(a)      (Xkb2CharsToInt((a)->high_YYY,(a)->low_YYY))
  156. #define    XkbSetPtrActionX(a,x) (XkbIntTo2Chars(x,(a)->high_XXX,(a)->low_XXX))
  157. #define    XkbSetPtrActionY(a,y) (XkbIntTo2Chars(y,(a)->high_YYY,(a)->low_YYY))
  158.  
  159. typedef struct _XkbPtrBtnAction {
  160.     unsigned char    type;
  161.     unsigned char    flags;
  162.     unsigned char    count;
  163.     unsigned char    button;
  164. } XkbPtrBtnAction;
  165.  
  166. typedef struct _XkbPtrDfltAction {
  167.     unsigned char    type;
  168.     unsigned char    flags;
  169.     unsigned char    affect;
  170.     char        valueXXX;
  171. } XkbPtrDfltAction;
  172. #define    XkbSAPtrDfltValue(a)        (XkbCharToInt((a)->valueXXX))
  173. #define    XkbSASetPtrDfltValue(a,c)    ((a)->valueXXX= ((c)&0xff))
  174.  
  175. typedef struct _XkbSwitchScreenAction {
  176.     unsigned char    type;
  177.     unsigned char    flags;
  178.     char        screenXXX;
  179. } XkbSwitchScreenAction;
  180. #define    XkbSAScreen(a)            (XkbCharToInt((a)->screenXXX))
  181. #define    XkbSASetScreen(a,s)        ((a)->screenXXX= ((s)&0xff))
  182.  
  183. typedef struct _XkbCtrlsAction {
  184.     unsigned char    type;
  185.     unsigned char    flags;
  186.     unsigned char    ctrls3;
  187.     unsigned char    ctrls2;
  188.     unsigned char    ctrls1;
  189.     unsigned char    ctrls0;
  190. } XkbCtrlsAction;
  191. #define    XkbActionSetCtrls(a,c)    (((a)->ctrls3=(((c)>>24)&0xff)),\
  192.                     ((a)->ctrls2=(((c)>>16)&0xff)),\
  193.                     ((a)->ctrls1=(((c)>>8)&0xff)),\
  194.                     ((a)->ctrls0=((c)&0xff)))
  195. #define    XkbActionCtrls(a) ((((unsigned int)(a)->ctrls3)<<24)|\
  196.                (((unsigned int)(a)->ctrls2)<<16)|\
  197.                (((unsigned int)(a)->ctrls1)<<8)|\
  198.                ((unsigned int)((a)->ctrls0)))
  199.  
  200. typedef struct _XkbMessageAction {
  201.     unsigned char    type;
  202.     unsigned char    flags;
  203.     unsigned char    message[6];
  204. } XkbMessageAction;
  205.  
  206. typedef struct    _XkbRedirectKeyAction {
  207.     unsigned char    type;
  208.     unsigned char    new_key;
  209.     unsigned char    mods_mask;
  210.     unsigned char    mods;
  211.     unsigned char    vmods_mask0;
  212.     unsigned char    vmods_mask1;
  213.     unsigned char    vmods0;
  214.     unsigned char    vmods1;
  215. } XkbRedirectKeyAction;
  216.  
  217. #define    XkbSARedirectVMods(a)        ((((unsigned int)(a)->vmods1)<<8)|\
  218.                     ((unsigned int)(a)->vmods0))
  219. #define    XkbSARedirectSetVMods(a,m)    (((a)->vmods_mask1=(((m)>>8)&0xff)),\
  220.                      ((a)->vmods_mask0=((m)&0xff)))
  221. #define    XkbSARedirectVModsMask(a)    ((((unsigned int)(a)->vmods_mask1)<<8)|\
  222.                     ((unsigned int)(a)->vmods_mask0))
  223. #define    XkbSARedirectSetVModsMask(a,m)    (((a)->vmods_mask1=(((m)>>8)&0xff)),\
  224.                      ((a)->vmods_mask0=((m)&0xff)))
  225.  
  226. typedef struct _XkbDeviceBtnAction {
  227.     unsigned char    type;
  228.     unsigned char    flags;
  229.     unsigned char    count;
  230.     unsigned char    button;
  231.     unsigned char    device;
  232. } XkbDeviceBtnAction;
  233.  
  234. typedef struct _XkbDeviceValuatorAction {
  235.     unsigned char    type;
  236.     unsigned char    device;
  237.     unsigned char    v1_what;
  238.     unsigned char    v1_ndx;
  239.     unsigned char    v1_value;
  240.     unsigned char    v2_what;
  241.     unsigned char    v2_ndx;
  242.     unsigned char    v2_value;
  243. } XkbDeviceValuatorAction;
  244.  
  245. typedef    union _XkbAction {
  246.     XkbAnyAction        any;
  247.     XkbModAction        mods;
  248.     XkbGroupAction        group;
  249.     XkbISOAction        iso;
  250.     XkbPtrAction        ptr;
  251.     XkbPtrBtnAction        btn;
  252.     XkbPtrDfltAction    dflt;
  253.     XkbSwitchScreenAction    screen;
  254.     XkbCtrlsAction        ctrls;
  255.     XkbMessageAction    msg;
  256.     XkbRedirectKeyAction    redirect;
  257.     XkbDeviceBtnAction    devbtn;
  258.     XkbDeviceValuatorAction    devval;
  259.     unsigned char         type;
  260. } XkbAction;
  261.  
  262. typedef    struct _XkbControls {
  263.     unsigned char    mk_dflt_btn;
  264.     unsigned char    num_groups;
  265.     unsigned char    groups_wrap;
  266.     XkbModsRec    internal;
  267.     XkbModsRec    ignore_lock;
  268.     unsigned int    enabled_ctrls;
  269.     unsigned short    repeat_delay;
  270.     unsigned short    repeat_interval;
  271.     unsigned short    slow_keys_delay;
  272.     unsigned short    debounce_delay;
  273.     unsigned short    mk_delay;
  274.     unsigned short    mk_interval;
  275.     unsigned short    mk_time_to_max;
  276.     unsigned short    mk_max_speed;
  277.          short    mk_curve;
  278.     unsigned short    ax_options;
  279.     unsigned short    ax_timeout;
  280.     unsigned short    axt_opts_mask;
  281.     unsigned short    axt_opts_values;
  282.     unsigned int    axt_ctrls_mask;
  283.     unsigned int    axt_ctrls_values;
  284.     unsigned char    per_key_repeat[XkbPerKeyBitArraySize];
  285. } XkbControlsRec, *XkbControlsPtr;
  286.  
  287. #define    XkbAX_AnyFeedback(c)    ((c)->enabled_ctrls&XkbAccessXFeedbackMask)
  288. #define    XkbAX_NeedOption(c,w)    ((c)->ax_options&(w))
  289. #define    XkbAX_NeedFeedback(c,w)    (XkbAX_AnyFeedback(c)&&XkbAX_NeedOption(c,w))
  290.  
  291. typedef struct _XkbServerMapRec {
  292.     unsigned short         num_acts;
  293.     unsigned short         size_acts;
  294.     XkbAction        *acts;
  295.  
  296.     XkbBehavior        *behaviors;
  297.     unsigned short        *key_acts;
  298. #if defined(__cplusplus) || defined(c_plusplus)
  299.     /* explicit is a C++ reserved word */
  300.     unsigned char        *c_explicit;
  301. #else
  302.     unsigned char        *explicit;
  303. #endif
  304.     unsigned char         vmods[XkbNumVirtualMods];
  305.     unsigned short        *vmodmap;
  306. } XkbServerMapRec, *XkbServerMapPtr;
  307.  
  308. #define    XkbSMKeyActionsPtr(m,k) (&(m)->acts[(m)->key_acts[k]])
  309.  
  310.     /*
  311.      * Structures and access macros used primarily by clients
  312.      */
  313.  
  314. typedef    struct _XkbSymMapRec {
  315.     unsigned char     kt_index[XkbNumKbdGroups];
  316.     unsigned char     group_info;
  317.     unsigned char     width;
  318.     unsigned short     offset;
  319. } XkbSymMapRec, *XkbSymMapPtr;
  320.  
  321. typedef struct _XkbClientMapRec {
  322.     unsigned char         size_types;
  323.     unsigned char         num_types;
  324.     XkbKeyTypePtr         types;
  325.  
  326.     unsigned short         size_syms;
  327.     unsigned short         num_syms;
  328.     KeySym            *syms;
  329.     XkbSymMapPtr         key_sym_map;
  330.  
  331.     unsigned char        *modmap;
  332. } XkbClientMapRec, *XkbClientMapPtr;
  333.  
  334. #define    XkbCMKeyGroupInfo(m,k)  ((m)->key_sym_map[k].group_info)
  335. #define    XkbCMKeyNumGroups(m,k)     (XkbNumGroups((m)->key_sym_map[k].group_info))
  336. #define    XkbCMKeyGroupWidth(m,k,g) (XkbCMKeyType(m,k,g)->num_levels)
  337. #define    XkbCMKeyGroupsWidth(m,k) ((m)->key_sym_map[k].width)
  338. #define    XkbCMKeyTypeIndex(m,k,g) ((m)->key_sym_map[k].kt_index[g&0x3])
  339. #define    XkbCMKeyType(m,k,g)     (&(m)->types[XkbCMKeyTypeIndex(m,k,g)])
  340. #define    XkbCMKeyNumSyms(m,k) (XkbCMKeyGroupsWidth(m,k)*XkbCMKeyNumGroups(m,k))
  341. #define    XkbCMKeySymsOffset(m,k)    ((m)->key_sym_map[k].offset)
  342. #define    XkbCMKeySymsPtr(m,k)    (&(m)->syms[XkbCMKeySymsOffset(m,k)])
  343.  
  344.     /*
  345.      * Compatibility structures and access macros
  346.      */
  347.  
  348. typedef struct _XkbSymInterpretRec {
  349.     KeySym        sym;
  350.     unsigned char    flags;
  351.     unsigned char    match;
  352.     unsigned char    mods;
  353.     unsigned char    virtual_mod;
  354.     XkbAnyAction    act;
  355. } XkbSymInterpretRec,*XkbSymInterpretPtr;
  356.  
  357. typedef struct _XkbCompatMapRec {
  358.     XkbSymInterpretPtr     sym_interpret;
  359.     XkbModsRec         groups[XkbNumKbdGroups];
  360.     unsigned short         num_si;
  361.     unsigned short         size_si;
  362. } XkbCompatMapRec, *XkbCompatMapPtr;
  363.  
  364. typedef struct _XkbIndicatorMapRec {
  365.     unsigned char    flags;
  366.     unsigned char    which_groups;
  367.     unsigned char    groups;
  368.     unsigned char    which_mods;
  369.     XkbModsRec    mods;
  370.     unsigned int    ctrls;
  371. } XkbIndicatorMapRec, *XkbIndicatorMapPtr;
  372.  
  373. #define    XkbIM_IsAuto(i)    ((((i)->flags&XkbIM_NoAutomatic)==0)&&\
  374.                 (((i)->which_groups&&(i)->groups)||\
  375.                  ((i)->which_mods&&(i)->mods.mask)||\
  376.                  ((i)->ctrls)))
  377. #define    XkbIM_InUse(i)    (((i)->flags)||((i)->which_groups)||\
  378.                     ((i)->which_mods)||((i)->ctrls))
  379.     
  380.  
  381. typedef struct _XkbIndicatorRec {
  382.     unsigned long          phys_indicators;
  383.     XkbIndicatorMapRec    maps[XkbNumIndicators];
  384. } XkbIndicatorRec,*XkbIndicatorPtr;
  385.  
  386. typedef    struct _XkbKeyNameRec {
  387.     char    name[XkbKeyNameLength];
  388. } XkbKeyNameRec,*XkbKeyNamePtr;
  389.  
  390. typedef struct _XkbKeyAliasRec {
  391.     char    real[XkbKeyNameLength];
  392.     char    alias[XkbKeyNameLength];
  393. } XkbKeyAliasRec,*XkbKeyAliasPtr;
  394.  
  395.     /*
  396.      * Names for everything 
  397.      */
  398. typedef struct _XkbNamesRec {
  399.     Atom          keycodes;
  400.     Atom          geometry;
  401.     Atom          symbols;
  402.     Atom              types;
  403.     Atom          compat;
  404.     Atom          vmods[XkbNumVirtualMods];
  405.     Atom          indicators[XkbNumIndicators];
  406.     Atom          groups[XkbNumKbdGroups];
  407.     XkbKeyNamePtr      keys;
  408.     XkbKeyAliasPtr      key_aliases;
  409.     Atom         *radio_groups;
  410.     Atom          phys_symbols;
  411.  
  412.     unsigned char      num_keys;
  413.     unsigned char      num_key_aliases;
  414.     unsigned short      num_rg;
  415. } XkbNamesRec,*XkbNamesPtr;
  416.  
  417. typedef    struct _XkbGeometry    *XkbGeometryPtr;
  418.     /*
  419.      * Tie it all together into one big keyboard description
  420.      */
  421. typedef    struct _XkbDesc {
  422.     struct _XDisplay *    dpy;
  423.     unsigned short         flags;
  424.     unsigned short        device_spec;
  425.     KeyCode            min_key_code;
  426.     KeyCode            max_key_code;
  427.  
  428.     XkbControlsPtr        ctrls;
  429.     XkbServerMapPtr        server;
  430.     XkbClientMapPtr        map;
  431.     XkbIndicatorPtr        indicators;
  432.     XkbNamesPtr        names;
  433.     XkbCompatMapPtr        compat;
  434.     XkbGeometryPtr        geom;
  435. } XkbDescRec, *XkbDescPtr;
  436. #define    XkbKeyKeyTypeIndex(d,k,g)    (XkbCMKeyTypeIndex((d)->map,k,g))
  437. #define    XkbKeyKeyType(d,k,g)        (XkbCMKeyType((d)->map,k,g))
  438. #define    XkbKeyGroupWidth(d,k,g)        (XkbCMKeyGroupWidth((d)->map,k,g))
  439. #define    XkbKeyGroupsWidth(d,k)        (XkbCMKeyGroupsWidth((d)->map,k))
  440. #define    XkbKeyGroupInfo(d,k)        (XkbCMKeyGroupInfo((d)->map,(k)))
  441. #define    XkbKeyNumGroups(d,k)        (XkbCMKeyNumGroups((d)->map,(k)))
  442. #define    XkbKeyNumSyms(d,k)        (XkbCMKeyNumSyms((d)->map,(k)))
  443. #define    XkbKeySymsPtr(d,k)        (XkbCMKeySymsPtr((d)->map,(k)))
  444. #define    XkbKeySym(d,k,n)        (XkbKeySymsPtr(d,k)[n])
  445. #define    XkbKeySymEntry(d,k,sl,g) \
  446.     (XkbKeySym(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl))))
  447. #define    XkbKeyAction(d,k,n) \
  448.     (XkbKeyHasActions(d,k)?&XkbKeyActionsPtr(d,k)[n]:NULL)
  449. #define    XkbKeyActionEntry(d,k,sl,g) \
  450.     (XkbKeyHasActions(d,k)?\
  451.         XkbKeyAction(d,k,((XkbKeyGroupsWidth(d,k)*(g))+(sl))):NULL)
  452.  
  453. #define    XkbKeyHasActions(d,k)    ((d)->server->key_acts[k]!=0)
  454. #define    XkbKeyNumActions(d,k)    (XkbKeyHasActions(d,k)?XkbKeyNumSyms(d,k):1)
  455. #define    XkbKeyActionsPtr(d,k)    (XkbSMKeyActionsPtr((d)->server,k))
  456. #define    XkbKeycodeInRange(d,k)    (((k)>=(d)->min_key_code)&&\
  457.                  ((k)<=(d)->max_key_code))
  458. #define    XkbNumKeys(d)        ((d)->max_key_code-(d)->min_key_code+1)
  459.  
  460.  
  461.     /*
  462.      * The following structures can be used to track changes
  463.      * to a keyboard device
  464.      */
  465. typedef struct _XkbMapChanges {
  466.     unsigned short         changed;
  467.     KeyCode             min_key_code;
  468.     KeyCode             max_key_code;
  469.     unsigned char         first_type;
  470.     unsigned char         num_types;
  471.     KeyCode             first_key_sym;
  472.     unsigned char         num_key_syms;
  473.     KeyCode             first_key_act;
  474.     unsigned char         num_key_acts;
  475.     KeyCode             first_key_behavior;
  476.     unsigned char         num_key_behaviors;
  477.     KeyCode          first_key_explicit;
  478.     unsigned char         num_key_explicit;
  479.     KeyCode             first_modmap_key;
  480.     unsigned char         num_modmap_keys;
  481.     KeyCode             first_vmodmap_key;
  482.     unsigned char         num_vmodmap_keys;
  483.     unsigned char         pad;
  484.     unsigned short         vmods;
  485. } XkbMapChangesRec,*XkbMapChangesPtr;
  486.  
  487. typedef struct _XkbControlsChanges {
  488.     unsigned int          changed_ctrls;
  489.     unsigned int         enabled_ctrls_changes;
  490.     Bool             num_groups_changed;
  491. } XkbControlsChangesRec,*XkbControlsChangesPtr;
  492.  
  493. typedef struct _XkbIndicatorChanges {
  494.     unsigned int         state_changes;
  495.     unsigned int         map_changes;
  496. } XkbIndicatorChangesRec,*XkbIndicatorChangesPtr;
  497.  
  498. typedef struct _XkbNameChanges {
  499.     unsigned int         changed;
  500.     unsigned char        first_type;
  501.     unsigned char        num_types;
  502.     unsigned char        first_lvl;
  503.     unsigned char        num_lvls;
  504.     unsigned char        num_aliases;
  505.     unsigned char        num_rg;
  506.     unsigned char        first_key;
  507.     unsigned char        num_keys;
  508.     unsigned short        changed_vmods;
  509.     unsigned long        changed_indicators;
  510.     unsigned char        changed_groups;
  511. } XkbNameChangesRec,*XkbNameChangesPtr;
  512.  
  513. typedef struct _XkbCompatChanges {
  514.     unsigned char        changed_groups;
  515.     unsigned short        first_si;
  516.     unsigned short        num_si;
  517. } XkbCompatChangesRec,*XkbCompatChangesPtr;
  518.  
  519. typedef struct _XkbChanges {
  520.     unsigned short         device_spec;
  521.     unsigned short         state_changes;
  522.     XkbMapChangesRec     map;
  523.     XkbControlsChangesRec     ctrls;
  524.     XkbIndicatorChangesRec     indicators;
  525.     XkbNameChangesRec     names;
  526.     XkbCompatChangesRec     compat;
  527. } XkbChangesRec, *XkbChangesPtr;
  528.  
  529.     /*
  530.      * These data structures are used to construct a keymap from 
  531.      * a set of components or to list components in the server
  532.      * database.
  533.      */
  534. typedef struct _XkbComponentNames {
  535.     char *             keymap;
  536.     char *             keycodes;
  537.     char *             types;
  538.     char *             compat;
  539.     char *             symbols;
  540.     char *             geometry;
  541. } XkbComponentNamesRec, *XkbComponentNamesPtr;
  542.  
  543. typedef struct _XkbComponentName {
  544.     unsigned short        flags;
  545.     char *            name;
  546. } XkbComponentNameRec,*XkbComponentNamePtr;
  547.  
  548. typedef struct _XkbComponentList {
  549.     int            num_keymaps;
  550.     int            num_keycodes;
  551.     int            num_types;
  552.     int            num_compat;
  553.     int            num_symbols;
  554.     int            num_geometry;
  555.     XkbComponentNamePtr    keymaps;
  556.     XkbComponentNamePtr     keycodes;
  557.     XkbComponentNamePtr    types;
  558.     XkbComponentNamePtr    compat;
  559.     XkbComponentNamePtr    symbols;
  560.     XkbComponentNamePtr    geometry;
  561. } XkbComponentListRec, *XkbComponentListPtr;
  562.  
  563.     /*
  564.      * The following data structures describe and track changes to a 
  565.      * non-keyboard extension device 
  566.      */
  567. typedef struct _XkbDeviceLedInfo {
  568.     unsigned short            led_class;
  569.     unsigned short            led_id;
  570.     unsigned int            phys_indicators;
  571.     unsigned int            maps_present;
  572.     unsigned int            names_present;
  573.     unsigned int            state;
  574.     Atom                 names[XkbNumIndicators];
  575.     XkbIndicatorMapRec        maps[XkbNumIndicators];
  576. } XkbDeviceLedInfoRec,*XkbDeviceLedInfoPtr;
  577.  
  578. typedef struct _XkbDeviceInfo {
  579.     char *            name;
  580.     Atom            type;
  581.     unsigned short        device_spec;
  582.     Bool            has_own_state;
  583.     unsigned short        supported;
  584.     unsigned short        unsupported;
  585.  
  586.     unsigned short        num_btns;
  587.     XkbAction *        btn_acts;
  588.  
  589.     unsigned short        sz_leds;
  590.     unsigned short        num_leds;
  591.     unsigned short        dflt_kbd_fb;
  592.     unsigned short        dflt_led_fb;
  593.     XkbDeviceLedInfoPtr    leds;
  594. } XkbDeviceInfoRec,*XkbDeviceInfoPtr;
  595.  
  596. #define    XkbXI_DevHasBtnActs(d)    (((d)->num_btns>0)&&((d)->btn_acts!=NULL))
  597. #define    XkbXI_LegalDevBtn(d,b)    (XkbXI_DevHasBtnActs(d)&&((b)<(d)->num_btns))
  598. #define    XkbXI_DevHasLeds(d)    (((d)->num_leds>0)&&((d)->leds!=NULL))
  599.  
  600. typedef struct _XkbDeviceLedChanges {
  601.     unsigned short        led_class;
  602.     unsigned short        led_id;
  603.     unsigned int        defined; /* names or maps changed */
  604.     struct _XkbDeviceLedChanges *next;
  605. } XkbDeviceLedChangesRec,*XkbDeviceLedChangesPtr;
  606.  
  607. typedef struct _XkbDeviceChanges {
  608.     unsigned int        changed;
  609.     unsigned short        first_btn;
  610.     unsigned short        num_btns;
  611.     XkbDeviceLedChangesRec     leds;
  612. } XkbDeviceChangesRec,*XkbDeviceChangesPtr;
  613.  
  614. #endif /* _XKBSTR_H_ */
  615.